home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Tournament Islands / Tournament Islands Large.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  50.5 KB  |  1,539 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Tournament Islands Large.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Creator: Richard Bishop $
  10. // $Version: 1.0 $
  11. // $Date:
  12. //
  13. //////////////////////////////////////////////////////////////////////
  14.  
  15. #if            NOTDEFINED(TOURNAMENT_ISLANDS_LARGE_RMV)
  16. #define        (TOURNAMENT_ISLANDS_LARGE_RMV,1)
  17.  
  18. //////////////////////////////////////////////////////////////////////
  19. // Definitions we are required to define for small island maps
  20. //////////////////////////////////////////////////////////////////////
  21.  
  22. ResourcePlacementLimit (Gold,     8,    10)
  23. ResourcePlacementLimit (Steel,     8,     10)
  24. ResourcePlacementLimit (Stone,     8,     10)
  25. ResourcePlacementLimit (Berry,     8,     10)
  26. ResourcePlacementLimit (Fish,     1,    45)
  27. ResourcePlacementLimit (Tree,     3,     4)
  28. ResourcePlacementLimit (Animal, 3,     15)
  29.  
  30. #if Is2Players
  31. //////////////////////////////////////////////////////////////////////
  32. // 2 PLAYERS...
  33. //////////////////////////////////////////////////////////////////////
  34.  
  35. PlaceWorldUnitInRing (Res-GoldMine, 14, 16)
  36. PlaceWorldUnitInRing (Res-Iron, 14, 16)
  37.  
  38. //////////////////////////////////////////////////////////////////////
  39. // terrain definitions
  40. #define        (kMinIntElevation,                -8)
  41. #define        (kMaxIntElevation,                10)
  42. #define        (kElevationScale,                      0.2)
  43. #define        (kPercentLand,                    Between(0.20, 0.20))
  44. #define        (kWaterBorder,                    15)
  45. #define        (kRiverWidth,                    19)
  46. #define        (kCoastToDeepWaterPercentage                  1.0)
  47. #define        (kHeightMapChaos,                    Between(15, 15))
  48.         
  49. #define        (kMinimumStartPositionToMapEdge        0)
  50. #define        (kOuterPushFromMapCenter            20)
  51. #define        (kInnerPushFromMapCenter             0)                                    
  52.  
  53. //////////////////////////////////////////////////////////////////////
  54. // player definitions
  55. #define        (kMaxAngleBetweenTeamMembers,           75.0)
  56. #define        (kPlayerInnerRadius,            0.5)
  57. #define        (kPlayerOuterRadius,            0.9)
  58. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  59. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  60. #define        (kPlayerLandChaos,            1)
  61. #define        (kPlayerLandClumps,            1)
  62. #define        (kPlayerFlatChaos,            1.0)
  63. #define        (kPlayerFlatClumps,            1)
  64. #define        (kPlayerTreePercentage,            0.1)
  65.  
  66.  
  67. //////////////////////////////////////////////////////////////////////
  68. // inner neutral definitions
  69. #define        (kNeutralInnerRadius,            0.05)
  70. #define        (kNeutralOuterRadius,            0.1)
  71. #define        (kNeutralOptimalFactor,            0.7)
  72. #define        (kNumInnerNeutrals,            Between(1, 1))
  73. #define        (kInnerNeutralPercentLand,        0.15)
  74. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  75. #define        (kInnerNeutralTreePercentage,          0.15)
  76. #define        (kInnerNeutralLandChaos,        1.0)
  77. #define        (kInnerNeutralLandClumps,        1)
  78. #define        (kInnerNeutralFlatChaos,        0.8)
  79. #define        (kInnerNeutralFlatClumps,        2)
  80.  
  81.  
  82. //////////////////////////////////////////////////////////////////////
  83. // outer neutral definitions
  84. #define        (kNumOuterNeutrals,            Between(2, 2))
  85. #define        (kOuterNeutralPercentLand,        0.3)
  86. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  87. #define        (kOuterNeutralTreePercentage,          0.09)
  88. #define        (kOuterNeutralLandChaos,        1.0)
  89. #define        (kOuterNeutralLandClumps,        1)
  90. #define        (kOuterNeutralFlatChaos,        1.0)
  91. #define        (kOuterNeutralFlatClumps,        2)
  92.  
  93.  
  94. //////////////////////////////////////////////////////////////////////
  95. // resource definitions
  96. #define        (kMaxResourceElevation,            2)
  97. #define        (kResourceToEdgeDistance,        1)
  98. #define        (kResourceToWaterDistance,        1)
  99.  
  100. #define        (kAnimalPerPlayer,            0)
  101. #define        (kAnimalPerNeutral,            0)
  102.  
  103. #define        (kBerryPerPlayer,                1)
  104. #define        (kBerryPerNeutral,            0)
  105.  
  106. #define        (kFishPerPlayer,                20)
  107. #define        (kFishPerNeutral,                90)
  108.  
  109. #define        (kGoldPerPlayer,                1)
  110. #define        (kGoldPerNeutral,                5)
  111.  
  112. #define        (kOilPerPlayer,                0)
  113. #define        (kOilPerNeutral,                0)
  114.  
  115. #define        (kSteelPerPlayer,                1)
  116. #define        (kSteelPerNeutral,            5)
  117.  
  118. #define        (kStonePerPlayer,                1)
  119. #define        (kStonePerNeutral,            2)
  120.  
  121. #define        (kTreePerPlayer,                1)
  122. #define        (kTreePerNeutral,                0)
  123.  
  124.  
  125. //////////////////////////////////////////////////////////////////////
  126. // forest definitions
  127. #define        (kForestFreeRadius,            6)
  128. #define        (kForestsPerPlayer,            2)
  129. #define        (kForestChaosLevel,            1)
  130. #define        (kMaxClumpsPerForest,            1)
  131.  
  132.  
  133. #elif Is3Players
  134. //////////////////////////////////////////////////////////////////////
  135. // 3 PLAYERS...
  136. //////////////////////////////////////////////////////////////////////
  137.  
  138. PlaceWorldUnitInRing (Res-GoldMine, 14, 16)
  139. PlaceWorldUnitInRing (Res-Iron, 14, 16)
  140.  
  141. //////////////////////////////////////////////////////////////////////
  142. // terrain definitions
  143. #define        (kMinIntElevation,                -8)
  144. #define        (kMaxIntElevation,                10)
  145. #define        (kElevationScale,                      0.2)
  146. #define        (kPercentLand,                    Between(0.26, 0.26))
  147. #define        (kWaterBorder,                    7)
  148. #define        (kRiverWidth,                    12)
  149. #define        (kCoastToDeepWaterPercentage                  1.0)
  150. #define        (kHeightMapChaos,                    Between(15, 15))
  151.         
  152. #define        (kMinimumStartPositionToMapEdge        0)
  153. #define        (kOuterPushFromMapCenter            20)
  154. #define        (kInnerPushFromMapCenter             0)                                    
  155.  
  156. //////////////////////////////////////////////////////////////////////
  157. // player definitions
  158. #define        (kMaxAngleBetweenTeamMembers,           75.0)
  159. #define        (kPlayerInnerRadius,            0.5)
  160. #define        (kPlayerOuterRadius,            0.9)
  161. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  162. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  163. #define        (kPlayerLandChaos,            1)
  164. #define        (kPlayerLandClumps,            1)
  165. #define        (kPlayerFlatChaos,            0.8)
  166. #define        (kPlayerFlatClumps,            1)
  167. #define        (kPlayerTreePercentage,            0.1)
  168.  
  169.  
  170. //////////////////////////////////////////////////////////////////////
  171. // inner neutral definitions
  172. #define        (kNeutralInnerRadius,            0.05)
  173. #define        (kNeutralOuterRadius,            0.1)
  174. #define        (kNeutralOptimalFactor,            0.7)
  175. #define        (kNumInnerNeutrals,            Between(1, 1))
  176. #define        (kInnerNeutralPercentLand,        0.15)
  177. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  178. #define        (kInnerNeutralTreePercentage,          0.15)
  179. #define        (kInnerNeutralLandChaos,        0.8)
  180. #define        (kInnerNeutralLandClumps,        1)
  181. #define        (kInnerNeutralFlatChaos,        0.8)
  182. #define        (kInnerNeutralFlatClumps,        2)
  183.  
  184.  
  185. //////////////////////////////////////////////////////////////////////
  186. // outer neutral definitions
  187. #define        (kNumOuterNeutrals,            Between(2, 2))
  188. #define        (kOuterNeutralPercentLand,        0.3)
  189. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  190. #define        (kOuterNeutralTreePercentage,          0.09)
  191. #define        (kOuterNeutralLandChaos,        1.0)
  192. #define        (kOuterNeutralLandClumps,        1)
  193. #define        (kOuterNeutralFlatChaos,        1.0)
  194. #define        (kOuterNeutralFlatClumps,        2)
  195.  
  196.  
  197. //////////////////////////////////////////////////////////////////////
  198. // resource definitions
  199. #define        (kMaxResourceElevation,            2)
  200. #define        (kResourceToEdgeDistance,        1)
  201. #define        (kResourceToWaterDistance,        1)
  202.  
  203. #define        (kAnimalPerPlayer,            0)
  204. #define        (kAnimalPerNeutral,            0)
  205.  
  206. #define        (kBerryPerPlayer,                1)
  207. #define        (kBerryPerNeutral,            0)
  208.  
  209. #define        (kFishPerPlayer,                20)
  210. #define        (kFishPerNeutral,                60)
  211.  
  212. #define        (kGoldPerPlayer,                1)
  213. #define        (kGoldPerNeutral,                4)
  214.  
  215. #define        (kOilPerPlayer,                0)
  216. #define        (kOilPerNeutral,                0)
  217.  
  218. #define        (kSteelPerPlayer,                1)
  219. #define        (kSteelPerNeutral,            4)
  220.  
  221. #define        (kStonePerPlayer,                1)
  222. #define        (kStonePerNeutral,            2)
  223.  
  224. #define        (kTreePerPlayer,                1)
  225. #define        (kTreePerNeutral,                0)
  226.  
  227.  
  228. //////////////////////////////////////////////////////////////////////
  229. // forest definitions
  230. #define        (kForestFreeRadius,            6)
  231. #define        (kForestsPerPlayer,            2)
  232. #define        (kForestChaosLevel,            1)
  233. #define        (kMaxClumpsPerForest,            1)
  234.  
  235. #elif Is4Players
  236. //////////////////////////////////////////////////////////////////////
  237. // 4 PLAYERS...
  238. //////////////////////////////////////////////////////////////////////
  239.  
  240. PlaceWorldUnitInRing (Res-GoldMine, 14, 16)
  241. PlaceWorldUnitInRing (Res-Iron, 14, 16)
  242.  
  243. //////////////////////////////////////////////////////////////////////
  244. // terrain definitions
  245. #define        (kMinIntElevation,                -8)
  246. #define        (kMaxIntElevation,                10)
  247. #define        (kElevationScale,                      0.2)
  248. #define        (kPercentLand,                    Between(0.34, 0.34))
  249. #define        (kWaterBorder,                    7)
  250. #define        (kRiverWidth,                    13)
  251. #define        (kCoastToDeepWaterPercentage                  1.0)
  252. #define        (kHeightMapChaos,                    Between(15, 15))
  253.         
  254. #define        (kMinimumStartPositionToMapEdge        0)
  255. #define        (kOuterPushFromMapCenter            20)
  256. #define        (kInnerPushFromMapCenter             0)                                    
  257.  
  258. //////////////////////////////////////////////////////////////////////
  259. // player definitions
  260. #define        (kMaxAngleBetweenTeamMembers,           75.0)
  261. #define        (kPlayerInnerRadius,            0.5)
  262. #define        (kPlayerOuterRadius,            0.9)
  263. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  264. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  265. #define        (kPlayerLandChaos,            1)
  266. #define        (kPlayerLandClumps,            1)
  267. #define        (kPlayerFlatChaos,            0.8)
  268. #define        (kPlayerFlatClumps,            1)
  269. #define        (kPlayerTreePercentage,            0.1)
  270.  
  271.  
  272. //////////////////////////////////////////////////////////////////////
  273. // inner neutral definitions
  274. #define        (kNeutralInnerRadius,            0.05)
  275. #define        (kNeutralOuterRadius,            0.3)
  276. #define        (kNeutralOptimalFactor,            0.6)
  277. #define        (kNumInnerNeutrals,            Between(2, 2))
  278. #define        (kInnerNeutralPercentLand,        0.12)
  279. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  280. #define        (kInnerNeutralTreePercentage,          0.15)
  281. #define        (kInnerNeutralLandChaos,        0.8)
  282. #define        (kInnerNeutralLandClumps,        1)
  283. #define        (kInnerNeutralFlatChaos,        0.8)
  284. #define        (kInnerNeutralFlatClumps,        2)
  285.  
  286.  
  287. //////////////////////////////////////////////////////////////////////
  288. // outer neutral definitions
  289. #define        (kNumOuterNeutrals,            Between(0, 0))
  290. #define        (kOuterNeutralPercentLand,        0.0)
  291. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  292. #define        (kOuterNeutralTreePercentage,          0.09)
  293. #define        (kOuterNeutralLandChaos,        1.0)
  294. #define        (kOuterNeutralLandClumps,        1)
  295. #define        (kOuterNeutralFlatChaos,        1.0)
  296. #define        (kOuterNeutralFlatClumps,        2)
  297.  
  298.  
  299. //////////////////////////////////////////////////////////////////////
  300. // resource definitions
  301. #define        (kMaxResourceElevation,            2)
  302. #define        (kResourceToEdgeDistance,        1)
  303. #define        (kResourceToWaterDistance,        1)
  304.  
  305. #define        (kAnimalPerPlayer,            0)
  306. #define        (kAnimalPerNeutral,            0)
  307.  
  308. #define        (kBerryPerPlayer,                1)
  309. #define        (kBerryPerNeutral,            0)
  310.  
  311. #define        (kFishPerPlayer,                20)
  312. #define        (kFishPerNeutral,                60)
  313.  
  314. #define        (kGoldPerPlayer,                1)
  315. #define        (kGoldPerNeutral,                4)
  316.  
  317. #define        (kOilPerPlayer,                0)
  318. #define        (kOilPerNeutral,                0)
  319.  
  320. #define        (kSteelPerPlayer,                1)
  321. #define        (kSteelPerNeutral,            4)
  322.  
  323. #define        (kStonePerPlayer,                1)
  324. #define        (kStonePerNeutral,            2)
  325.  
  326. #define        (kTreePerPlayer,                1)
  327. #define        (kTreePerNeutral,                0)
  328.  
  329.  
  330. //////////////////////////////////////////////////////////////////////
  331. // forest definitions
  332. #define        (kForestFreeRadius,            6)
  333. #define        (kForestsPerPlayer,            2)
  334. #define        (kForestChaosLevel,            1)
  335. #define        (kMaxClumpsPerForest,            1)
  336.  
  337. #elif Is5Players
  338. //////////////////////////////////////////////////////////////////////
  339. // 5 PLAYERS...
  340. //////////////////////////////////////////////////////////////////////
  341.  
  342. PlaceWorldUnitInRing (Res-GoldMine, 14, 16)
  343. PlaceWorldUnitInRing (Res-Iron, 14, 16)
  344.  
  345. //////////////////////////////////////////////////////////////////////
  346. // terrain definitions
  347. #define        (kMinIntElevation,                -8)
  348. #define        (kMaxIntElevation,                10)
  349. #define        (kElevationScale,                      0.2)
  350. #define        (kPercentLand,                    Between(0.33, 0.33))
  351. #define        (kWaterBorder,                    7)
  352. #define        (kRiverWidth,                    13)
  353. #define        (kCoastToDeepWaterPercentage                  1.0)
  354. #define        (kHeightMapChaos,                    Between(15, 15))
  355.         
  356. #define        (kMinimumStartPositionToMapEdge        0)
  357. #define        (kOuterPushFromMapCenter            20)
  358. #define        (kInnerPushFromMapCenter             0)                                    
  359.  
  360. //////////////////////////////////////////////////////////////////////
  361. // player definitions
  362. #define        (kMaxAngleBetweenTeamMembers,           75.0)
  363. #define        (kPlayerInnerRadius,            0.5)
  364. #define        (kPlayerOuterRadius,            0.9)
  365. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  366. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  367. #define        (kPlayerLandChaos,            1)
  368. #define        (kPlayerLandClumps,            1)
  369. #define        (kPlayerFlatChaos,            0.8)
  370. #define        (kPlayerFlatClumps,            1)
  371. #define        (kPlayerTreePercentage,            0.1)
  372.  
  373.  
  374. //////////////////////////////////////////////////////////////////////
  375. // inner neutral definitions
  376. #define        (kNeutralInnerRadius,            0.05)
  377. #define        (kNeutralOuterRadius,            0.3)
  378. #define        (kNeutralOptimalFactor,            0.6)
  379. #define        (kNumInnerNeutrals,            Between(2, 2))
  380. #define        (kInnerNeutralPercentLand,        0.12)
  381. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  382. #define        (kInnerNeutralTreePercentage,          0.15)
  383. #define        (kInnerNeutralLandChaos,        0.8)
  384. #define        (kInnerNeutralLandClumps,        1)
  385. #define        (kInnerNeutralFlatChaos,        0.8)
  386. #define        (kInnerNeutralFlatClumps,        2)
  387.  
  388.  
  389. //////////////////////////////////////////////////////////////////////
  390. // outer neutral definitions
  391. #define        (kNumOuterNeutrals,            Between(0, 0))
  392. #define        (kOuterNeutralPercentLand,        0.0)
  393. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  394. #define        (kOuterNeutralTreePercentage,          0.09)
  395. #define        (kOuterNeutralLandChaos,        1.0)
  396. #define        (kOuterNeutralLandClumps,        1)
  397. #define        (kOuterNeutralFlatChaos,        1.0)
  398. #define        (kOuterNeutralFlatClumps,        2)
  399.  
  400.  
  401. //////////////////////////////////////////////////////////////////////
  402. // resource definitions
  403. #define        (kMaxResourceElevation,            2)
  404. #define        (kResourceToEdgeDistance,        1)
  405. #define        (kResourceToWaterDistance,        1)
  406.  
  407. #define        (kAnimalPerPlayer,            0)
  408. #define        (kAnimalPerNeutral,            0)
  409.  
  410. #define        (kBerryPerPlayer,                1)
  411. #define        (kBerryPerNeutral,            0)
  412.  
  413. #define        (kFishPerPlayer,                20)
  414. #define        (kFishPerNeutral,                60)
  415.  
  416. #define        (kGoldPerPlayer,                1)
  417. #define        (kGoldPerNeutral,                5)
  418.  
  419. #define        (kOilPerPlayer,                    0)
  420. #define        (kOilPerNeutral,                0)
  421.  
  422. #define        (kSteelPerPlayer,                1)
  423. #define        (kSteelPerNeutral,                5)
  424.  
  425. #define        (kStonePerPlayer,                1)
  426. #define        (kStonePerNeutral,                2)
  427.  
  428. #define        (kTreePerPlayer,                1)
  429. #define        (kTreePerNeutral,                0)
  430.  
  431.  
  432. //////////////////////////////////////////////////////////////////////
  433. // forest definitions
  434. #define        (kForestFreeRadius,            6)
  435. #define        (kForestsPerPlayer,            2)
  436. #define        (kForestChaosLevel,            1)
  437. #define        (kMaxClumpsPerForest,            1)
  438.  
  439. #elif Is6Players
  440. //////////////////////////////////////////////////////////////////////
  441. // 6 PLAYERS...
  442. //////////////////////////////////////////////////////////////////////
  443.  
  444. PlaceWorldUnitInRing (Res-GoldMine, 14, 16)
  445. PlaceWorldUnitInRing (Res-Iron, 14, 16)
  446.  
  447. //////////////////////////////////////////////////////////////////////
  448. // terrain definitions
  449. #define        (kMinIntElevation,                -8)
  450. #define        (kMaxIntElevation,                10)
  451. #define        (kElevationScale,                      0.2)
  452. #define        (kPercentLand,                    Between(0.33, 0.33))
  453. #define        (kWaterBorder,                    7)
  454. #define        (kRiverWidth,                    13)
  455. #define        (kCoastToDeepWaterPercentage                  1.0)
  456. #define        (kHeightMapChaos,                    Between(15, 15))
  457.         
  458. #define        (kMinimumStartPositionToMapEdge        0)
  459. #define        (kOuterPushFromMapCenter            20)
  460. #define        (kInnerPushFromMapCenter             0)                                    
  461.  
  462. //////////////////////////////////////////////////////////////////////
  463. // player definitions
  464. #define        (kMaxAngleBetweenTeamMembers,           75.0)
  465. #define        (kPlayerInnerRadius,            0.5)
  466. #define        (kPlayerOuterRadius,            0.9)
  467. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  468. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  469. #define        (kPlayerLandChaos,            1)
  470. #define        (kPlayerLandClumps,            1)
  471. #define        (kPlayerFlatChaos,            0.8)
  472. #define        (kPlayerFlatClumps,            1)
  473. #define        (kPlayerTreePercentage,            0.1)
  474.  
  475.  
  476. //////////////////////////////////////////////////////////////////////
  477. // inner neutral definitions
  478. #define        (kNeutralInnerRadius,            0.05)
  479. #define        (kNeutralOuterRadius,            0.3)
  480. #define        (kNeutralOptimalFactor,            0.7)
  481. #define        (kNumInnerNeutrals,            Between(2, 2))
  482. #define        (kInnerNeutralPercentLand,        0.1)
  483. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  484. #define        (kInnerNeutralTreePercentage,          0.15)
  485. #define        (kInnerNeutralLandChaos,        1.0)
  486. #define        (kInnerNeutralLandClumps,        1)
  487. #define        (kInnerNeutralFlatChaos,        0.8)
  488. #define        (kInnerNeutralFlatClumps,        2)
  489.  
  490.  
  491. //////////////////////////////////////////////////////////////////////
  492. // outer neutral definitions
  493. #define        (kNumOuterNeutrals,            Between(0, 0))
  494. #define        (kOuterNeutralPercentLand,        0.4)
  495. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  496. #define        (kOuterNeutralTreePercentage,          0.09)
  497. #define        (kOuterNeutralLandChaos,        1.0)
  498. #define        (kOuterNeutralLandClumps,        1)
  499. #define        (kOuterNeutralFlatChaos,        1.0)
  500. #define        (kOuterNeutralFlatClumps,        2)
  501.  
  502.  
  503. //////////////////////////////////////////////////////////////////////
  504. // resource definitions
  505. #define        (kMaxResourceElevation,            2)
  506. #define        (kResourceToEdgeDistance,        1)
  507. #define        (kResourceToWaterDistance,        1)
  508.  
  509. #define        (kAnimalPerPlayer,            0)
  510. #define        (kAnimalPerNeutral,            0)
  511.  
  512. #define        (kBerryPerPlayer,                1)
  513. #define        (kBerryPerNeutral,            0)
  514.  
  515. #define        (kFishPerPlayer,                20)
  516. #define        (kFishPerNeutral,                20)
  517.  
  518. #define        (kGoldPerPlayer,                1)
  519. #define        (kGoldPerNeutral,                4)
  520.  
  521. #define        (kOilPerPlayer,                0)
  522. #define        (kOilPerNeutral,                0)
  523.  
  524. #define        (kSteelPerPlayer,                1)
  525. #define        (kSteelPerNeutral,                4)
  526.  
  527. #define        (kStonePerPlayer,                1)
  528. #define        (kStonePerNeutral,                2)
  529.  
  530. #define        (kTreePerPlayer,                1)
  531. #define        (kTreePerNeutral,                0)
  532.  
  533. //////////////////////////////////////////////////////////////////////
  534. // forest definitions
  535. #define        (kForestFreeRadius,            6)
  536. #define        (kForestsPerPlayer,            2)
  537. #define        (kForestChaosLevel,            1)
  538. #define        (kMaxClumpsPerForest,            1)
  539.  
  540. #elif Is7Players
  541. //////////////////////////////////////////////////////////////////////
  542. // 7 PLAYERS...
  543. //////////////////////////////////////////////////////////////////////
  544.  
  545. PlaceWorldUnitInRing (Res-GoldMine, 14, 16)
  546. PlaceWorldUnitInRing (Res-Iron, 14, 16)
  547.  
  548. //////////////////////////////////////////////////////////////////////
  549. // terrain definitions
  550. #define        (kMinIntElevation,                -8)
  551. #define        (kMaxIntElevation,                10)
  552. #define        (kElevationScale,                      0.2)
  553. #define        (kPercentLand,                    Between(0.35, 0.35))
  554. #define        (kWaterBorder,                    7)
  555. #define        (kRiverWidth,                    12)
  556. #define        (kCoastToDeepWaterPercentage                  1.0)
  557. #define        (kHeightMapChaos,                    Between(15, 15))
  558.         
  559. #define        (kMinimumStartPositionToMapEdge        0)
  560. #define        (kOuterPushFromMapCenter            20)
  561. #define        (kInnerPushFromMapCenter             0)                                    
  562.  
  563. //////////////////////////////////////////////////////////////////////
  564. // player definitions
  565. #define        (kMaxAngleBetweenTeamMembers,           75.0)
  566. #define        (kPlayerInnerRadius,            0.5)
  567. #define        (kPlayerOuterRadius,            0.9)
  568. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  569. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  570. #define        (kPlayerLandChaos,            1)
  571. #define        (kPlayerLandClumps,            1)
  572. #define        (kPlayerFlatChaos,            0.8)
  573. #define        (kPlayerFlatClumps,            1)
  574. #define        (kPlayerTreePercentage,            0.1)
  575.  
  576.  
  577. //////////////////////////////////////////////////////////////////////
  578. // inner neutral definitions
  579. #define        (kNeutralInnerRadius,            0.05)
  580. #define        (kNeutralOuterRadius,            0.3)
  581. #define        (kNeutralOptimalFactor,            0.7)
  582. #define        (kNumInnerNeutrals,            Between(2, 2))
  583. #define        (kInnerNeutralPercentLand,        0.1)
  584. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  585. #define        (kInnerNeutralTreePercentage,          0.15)
  586. #define        (kInnerNeutralLandChaos,        1.0)
  587. #define        (kInnerNeutralLandClumps,        1)
  588. #define        (kInnerNeutralFlatChaos,        0.8)
  589. #define        (kInnerNeutralFlatClumps,        2)
  590.  
  591.  
  592. //////////////////////////////////////////////////////////////////////
  593. // outer neutral definitions
  594. #define        (kNumOuterNeutrals,            Between(0, 0))
  595. #define        (kOuterNeutralPercentLand,        0.4)
  596. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  597. #define        (kOuterNeutralTreePercentage,          0.09)
  598. #define        (kOuterNeutralLandChaos,        1.0)
  599. #define        (kOuterNeutralLandClumps,        1)
  600. #define        (kOuterNeutralFlatChaos,        1.0)
  601. #define        (kOuterNeutralFlatClumps,        2)
  602.  
  603.  
  604. //////////////////////////////////////////////////////////////////////
  605. // resource definitions
  606. #define        (kMaxResourceElevation,            2)
  607. #define        (kResourceToEdgeDistance,        1)
  608. #define        (kResourceToWaterDistance,        1)
  609.  
  610. #define        (kAnimalPerPlayer,            0)
  611. #define        (kAnimalPerNeutral,            0)
  612.  
  613. #define        (kBerryPerPlayer,                1)
  614. #define        (kBerryPerNeutral,            0)
  615.  
  616. #define        (kFishPerPlayer,                20)
  617. #define        (kFishPerNeutral,                20)
  618.  
  619. #define        (kGoldPerPlayer,                1)
  620. #define        (kGoldPerNeutral,                2)
  621.  
  622. #define        (kOilPerPlayer,                0)
  623. #define        (kOilPerNeutral,                0)
  624.  
  625. #define        (kSteelPerPlayer,                1)
  626. #define        (kSteelPerNeutral,            2)
  627.  
  628. #define        (kStonePerPlayer,                1)
  629. #define        (kStonePerNeutral,            1)
  630.  
  631. #define        (kTreePerPlayer,                1)
  632. #define        (kTreePerNeutral,                0)
  633.  
  634. //////////////////////////////////////////////////////////////////////
  635. // forest definitions
  636. #define        (kForestFreeRadius,            6)
  637. #define        (kForestsPerPlayer,            2)
  638. #define        (kForestChaosLevel,            1)
  639. #define        (kMaxClumpsPerForest,            1)
  640.  
  641. #elif Is8Players
  642. //////////////////////////////////////////////////////////////////////
  643. // 8 PLAYERS...
  644. //////////////////////////////////////////////////////////////////////
  645.  
  646. PlaceWorldUnitInRing (Res-GoldMine, 14, 16)
  647. PlaceWorldUnitInRing (Res-Iron, 14, 16)
  648.  
  649. //////////////////////////////////////////////////////////////////////
  650. // terrain definitions
  651. #define        (kMinIntElevation,                -8)
  652. #define        (kMaxIntElevation,                10)
  653. #define        (kElevationScale,                      0.2)
  654. #define        (kPercentLand,                    Between(0.37, 0.37))
  655. #define        (kWaterBorder,                    7)
  656. #define        (kRiverWidth,                    12)
  657. #define        (kCoastToDeepWaterPercentage                  1.0)
  658. #define        (kHeightMapChaos,                    Between(15, 15))
  659.         
  660. #define        (kMinimumStartPositionToMapEdge        0)
  661. #define        (kOuterPushFromMapCenter            20)
  662. #define        (kInnerPushFromMapCenter             0)                                    
  663.  
  664. //////////////////////////////////////////////////////////////////////
  665. // player definitions
  666. #define        (kMaxAngleBetweenTeamMembers,           75.0)
  667. #define        (kPlayerInnerRadius,            0.5)
  668. #define        (kPlayerOuterRadius,            0.9)
  669. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  670. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  671. #define        (kPlayerLandChaos,            1)
  672. #define        (kPlayerLandClumps,            1)
  673. #define        (kPlayerFlatChaos,            0.8)
  674. #define        (kPlayerFlatClumps,            1)
  675. #define        (kPlayerTreePercentage,            0.1)
  676.  
  677.  
  678. //////////////////////////////////////////////////////////////////////
  679. // inner neutral definitions
  680. #define        (kNeutralInnerRadius,            0.05)
  681. #define        (kNeutralOuterRadius,            0.3)
  682. #define        (kNeutralOptimalFactor,            0.7)
  683. #define        (kNumInnerNeutrals,            Between(2, 2))
  684. #define        (kInnerNeutralPercentLand,        0.1)
  685. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  686. #define        (kInnerNeutralTreePercentage,          0.15)
  687. #define        (kInnerNeutralLandChaos,        1.0)
  688. #define        (kInnerNeutralLandClumps,        1)
  689. #define        (kInnerNeutralFlatChaos,        0.8)
  690. #define        (kInnerNeutralFlatClumps,        2)
  691.  
  692.  
  693. //////////////////////////////////////////////////////////////////////
  694. // outer neutral definitions
  695. #define        (kNumOuterNeutrals,            Between(0, 0))
  696. #define        (kOuterNeutralPercentLand,        0.4)
  697. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  698. #define        (kOuterNeutralTreePercentage,          0.09)
  699. #define        (kOuterNeutralLandChaos,        1.0)
  700. #define        (kOuterNeutralLandClumps,        1)
  701. #define        (kOuterNeutralFlatChaos,        1.0)
  702. #define        (kOuterNeutralFlatClumps,        2)
  703.  
  704.  
  705. //////////////////////////////////////////////////////////////////////
  706. // resource definitions
  707. #define        (kMaxResourceElevation,            2)
  708. #define        (kResourceToEdgeDistance,        1)
  709. #define        (kResourceToWaterDistance,        1)
  710.  
  711. #define        (kAnimalPerPlayer,            0)
  712. #define        (kAnimalPerNeutral,            0)
  713.  
  714. #define        (kBerryPerPlayer,                1)
  715. #define        (kBerryPerNeutral,                0)
  716.  
  717. #define        (kFishPerPlayer,                20)
  718. #define        (kFishPerNeutral,                20)
  719.  
  720. #define        (kGoldPerPlayer,                1)
  721. #define        (kGoldPerNeutral,                2)
  722.  
  723. #define        (kOilPerPlayer,                    0)
  724. #define        (kOilPerNeutral,                0)
  725.  
  726. #define        (kSteelPerPlayer,                1)
  727. #define        (kSteelPerNeutral,                2)
  728.  
  729. #define        (kStonePerPlayer,                1)
  730. #define        (kStonePerNeutral,                1)
  731.  
  732. #define        (kTreePerPlayer,                1)
  733. #define        (kTreePerNeutral,                0)
  734.  
  735. //////////////////////////////////////////////////////////////////////
  736. // forest definitions
  737. #define        (kForestFreeRadius,            6)
  738. #define        (kForestsPerPlayer,            2)
  739. #define        (kForestChaosLevel,            1)
  740. #define        (kMaxClumpsPerForest,            1)
  741.  
  742. #elif Is9Players
  743. //////////////////////////////////////////////////////////////////////
  744. // 9 PLAYERS...
  745. //////////////////////////////////////////////////////////////////////
  746.  
  747. //////////////////////////////////////////////////////////////////////
  748. // terrain definitions
  749. #define        (kMinIntElevation,                -10)
  750. #define        (kMaxIntElevation,                12)
  751. #define        (kElevationScale,                      1)
  752. #define        (kPercentLand,                    Between(0.59, 0.59))
  753. #define        (kWaterBorder,                    0)
  754. #define        (kRiverWidth,                    8)
  755. #define        (kCoastToDeepWaterPercentage                1.0)
  756. #define        (kHeightMapChaos,                    Between(6, 15))
  757.         
  758. #define        (kMinimumStartPositionToMapEdge        0)
  759. #define        (kOuterPushFromMapCenter            13)
  760. #define        (kInnerPushFromMapCenter             0)
  761.  
  762. //////////////////////////////////////////////////////////////////////
  763. // player definitions
  764. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  765. #define        (kPlayerInnerRadius,            0.01)
  766. #define        (kPlayerOuterRadius,            0.9)
  767. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  768. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  769. #define        (kPlayerLandChaos,            0.8)
  770. #define        (kPlayerLandClumps,            1)
  771. #define        (kPlayerFlatChaos,            0.8)
  772. #define        (kPlayerFlatClumps,            2)
  773. #define        (kPlayerTreePercentage,            0.04)
  774.  
  775.  
  776. //////////////////////////////////////////////////////////////////////
  777. // inner neutral definitions
  778. #define        (kNeutralInnerRadius,            0.05)
  779. #define        (kNeutralOuterRadius,            0.4)
  780. #define        (kNeutralOptimalFactor,            0.7)
  781. #define        (kNumInnerNeutrals,            Between(0, 0))
  782. #define        (kInnerNeutralPercentLand,        0.35)
  783. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  784. #define        (kInnerNeutralTreePercentage,          0.04)
  785. #define        (kInnerNeutralLandChaos,        0.8)
  786. #define        (kInnerNeutralLandClumps,        1)
  787. #define        (kInnerNeutralFlatChaos,        0.8)
  788. #define        (kInnerNeutralFlatClumps,        2)
  789.  
  790.  
  791. //////////////////////////////////////////////////////////////////////
  792. // outer neutral definitions
  793. #define        (kNumOuterNeutrals,            Between(0, 0))
  794. #define        (kOuterNeutralPercentLand,        0.35)
  795. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  796. #define        (kOuterNeutralTreePercentage,          0.04)
  797. #define        (kOuterNeutralLandChaos,        0.8)
  798. #define        (kOuterNeutralLandClumps,        1)
  799. #define        (kOuterNeutralFlatChaos,        0.8)
  800. #define        (kOuterNeutralFlatClumps,        2)
  801.  
  802.  
  803. //////////////////////////////////////////////////////////////////////
  804. // resource definitions
  805. #define        (kMaxResourceElevation,            2)
  806. #define        (kResourceToEdgeDistance,        2)
  807. #define        (kResourceToWaterDistance,        2)
  808.  
  809. #define        (kAnimalPerPlayer,            0)
  810. #define        (kAnimalPerNeutral,            0)
  811.  
  812. #define        (kBerryPerPlayer,                0)
  813. #define        (kBerryPerNeutral,            0)
  814.  
  815. #define        (kFishPerPlayer,                10)
  816. #define        (kFishPerNeutral,                0)
  817.  
  818. #define        (kGoldPerPlayer,                1)
  819. #define        (kGoldPerNeutral,                0)
  820.  
  821. #define        (kOilPerPlayer,                0)
  822. #define        (kOilPerNeutral,                0)
  823.  
  824. #define        (kSteelPerPlayer,                1)
  825. #define        (kSteelPerNeutral,            0)
  826.  
  827. #define        (kStonePerPlayer,                1)
  828. #define        (kStonePerNeutral,            0)
  829.  
  830. #define        (kTreePerPlayer,                0)
  831. #define        (kTreePerNeutral,                0)
  832.  
  833. //////////////////////////////////////////////////////////////////////
  834. // forest definitions
  835. #define        (kForestFreeRadius,            3)
  836. #define        (kForestsPerPlayer,            3)
  837. #define        (kForestChaosLevel,            0.1)
  838. #define        (kMaxClumpsPerForest,            2)
  839.  
  840.  
  841. #elif Is10Players
  842. //////////////////////////////////////////////////////////////////////
  843. // 10 PLAYERS...
  844. //////////////////////////////////////////////////////////////////////
  845.  
  846. //////////////////////////////////////////////////////////////////////
  847. // terrain definitions
  848. #define        (kMinIntElevation,                -10)
  849. #define        (kMaxIntElevation,                12)
  850. #define        (kElevationScale,                      1)
  851. #define        (kPercentLand,                    Between(0.58, 0.58))
  852. #define        (kWaterBorder,                    0)
  853. #define        (kRiverWidth,                    7)
  854. #define        (kCoastToDeepWaterPercentage                1.0)
  855. #define        (kHeightMapChaos,                    Between(6, 15))
  856.         
  857. #define        (kMinimumStartPositionToMapEdge        0)
  858. #define        (kOuterPushFromMapCenter            12)
  859. #define        (kInnerPushFromMapCenter             0)
  860.  
  861. //////////////////////////////////////////////////////////////////////
  862. // player definitions
  863. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  864. #define        (kPlayerInnerRadius,            0.01)
  865. #define        (kPlayerOuterRadius,            0.9)
  866. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  867. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  868. #define        (kPlayerLandChaos,            0.8)
  869. #define        (kPlayerLandClumps,            1)
  870. #define        (kPlayerFlatChaos,            0.8)
  871. #define        (kPlayerFlatClumps,            2)
  872. #define        (kPlayerTreePercentage,            0.04)
  873.  
  874.  
  875. //////////////////////////////////////////////////////////////////////
  876. // inner neutral definitions
  877. #define        (kNeutralInnerRadius,            0.05)
  878. #define        (kNeutralOuterRadius,            0.4)
  879. #define        (kNeutralOptimalFactor,            0.7)
  880. #define        (kNumInnerNeutrals,            Between(0, 0))
  881. #define        (kInnerNeutralPercentLand,        0.35)
  882. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  883. #define        (kInnerNeutralTreePercentage,          0.04)
  884. #define        (kInnerNeutralLandChaos,        0.8)
  885. #define        (kInnerNeutralLandClumps,        1)
  886. #define        (kInnerNeutralFlatChaos,        0.8)
  887. #define        (kInnerNeutralFlatClumps,        2)
  888.  
  889.  
  890. //////////////////////////////////////////////////////////////////////
  891. // outer neutral definitions
  892. #define        (kNumOuterNeutrals,            Between(0, 0))
  893. #define        (kOuterNeutralPercentLand,        0.35)
  894. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  895. #define        (kOuterNeutralTreePercentage,          0.04)
  896. #define        (kOuterNeutralLandChaos,        0.8)
  897. #define        (kOuterNeutralLandClumps,        1)
  898. #define        (kOuterNeutralFlatChaos,        0.8)
  899. #define        (kOuterNeutralFlatClumps,        2)
  900.  
  901.  
  902. //////////////////////////////////////////////////////////////////////
  903. // resource definitions
  904. #define        (kMaxResourceElevation,            2)
  905. #define        (kResourceToEdgeDistance,        2)
  906. #define        (kResourceToWaterDistance,        2)
  907.  
  908. #define        (kAnimalPerPlayer,            0)
  909. #define        (kAnimalPerNeutral,            0)
  910.  
  911. #define        (kBerryPerPlayer,                0)
  912. #define        (kBerryPerNeutral,            0)
  913.  
  914. #define        (kFishPerPlayer,                9)
  915. #define        (kFishPerNeutral,                0)
  916.  
  917. #define        (kGoldPerPlayer,                1)
  918. #define        (kGoldPerNeutral,                0)
  919.  
  920. #define        (kOilPerPlayer,                0)
  921. #define        (kOilPerNeutral,                0)
  922.  
  923. #define        (kSteelPerPlayer,                1)
  924. #define        (kSteelPerNeutral,            0)
  925.  
  926. #define        (kStonePerPlayer,                1)
  927. #define        (kStonePerNeutral,            0)
  928.  
  929. #define        (kTreePerPlayer,                0)
  930. #define        (kTreePerNeutral,                0)
  931.  
  932. //////////////////////////////////////////////////////////////////////
  933. // forest definitions
  934. #define        (kForestFreeRadius,            3)
  935. #define        (kForestsPerPlayer,            3)
  936. #define        (kForestChaosLevel,            0.1)
  937. #define        (kMaxClumpsPerForest,            2)
  938.  
  939.  
  940. #elif Is11Players
  941. //////////////////////////////////////////////////////////////////////
  942. // 11 PLAYERS...
  943. //////////////////////////////////////////////////////////////////////
  944.  
  945. //////////////////////////////////////////////////////////////////////
  946. // terrain definitions
  947. #define        (kMinIntElevation,                -10)
  948. #define        (kMaxIntElevation,                12)
  949. #define        (kElevationScale,                      1)
  950. #define        (kPercentLand,                    Between(0.57, 0.57))
  951. #define        (kWaterBorder,                    0)
  952. #define        (kRiverWidth,                    7)
  953. #define        (kCoastToDeepWaterPercentage                1.0)
  954. #define        (kHeightMapChaos,                    Between(6, 15))
  955.         
  956. #define        (kMinimumStartPositionToMapEdge        0)
  957. #define        (kOuterPushFromMapCenter            12)
  958. #define        (kInnerPushFromMapCenter             0)
  959.  
  960. //////////////////////////////////////////////////////////////////////
  961. // player definitions
  962. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  963. #define        (kPlayerInnerRadius,            0.01)
  964. #define        (kPlayerOuterRadius,            0.9)
  965. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  966. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  967. #define        (kPlayerLandChaos,            0.8)
  968. #define        (kPlayerLandClumps,            1)
  969. #define        (kPlayerFlatChaos,            0.8)
  970. #define        (kPlayerFlatClumps,            2)
  971. #define        (kPlayerTreePercentage,            0.04)
  972.  
  973.  
  974. //////////////////////////////////////////////////////////////////////
  975. // inner neutral definitions
  976. #define        (kNeutralInnerRadius,            0.05)
  977. #define        (kNeutralOuterRadius,            0.4)
  978. #define        (kNeutralOptimalFactor,            0.7)
  979. #define        (kNumInnerNeutrals,            Between(0, 0))
  980. #define        (kInnerNeutralPercentLand,        0.35)
  981. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  982. #define        (kInnerNeutralTreePercentage,          0.04)
  983. #define        (kInnerNeutralLandChaos,        0.8)
  984. #define        (kInnerNeutralLandClumps,        1)
  985. #define        (kInnerNeutralFlatChaos,        0.8)
  986. #define        (kInnerNeutralFlatClumps,        2)
  987.  
  988.  
  989. //////////////////////////////////////////////////////////////////////
  990. // outer neutral definitions
  991. #define        (kNumOuterNeutrals,            Between(0, 0))
  992. #define        (kOuterNeutralPercentLand,        0.35)
  993. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  994. #define        (kOuterNeutralTreePercentage,          0.04)
  995. #define        (kOuterNeutralLandChaos,        0.8)
  996. #define        (kOuterNeutralLandClumps,        1)
  997. #define        (kOuterNeutralFlatChaos,        0.8)
  998. #define        (kOuterNeutralFlatClumps,        2)
  999.  
  1000.  
  1001. //////////////////////////////////////////////////////////////////////
  1002. // resource definitions
  1003. #define        (kMaxResourceElevation,            2)
  1004. #define        (kResourceToEdgeDistance,        2)
  1005. #define        (kResourceToWaterDistance,        2)
  1006.  
  1007. #define        (kAnimalPerPlayer,            0)
  1008. #define        (kAnimalPerNeutral,            0)
  1009.  
  1010. #define        (kBerryPerPlayer,                0)
  1011. #define        (kBerryPerNeutral,            0)
  1012.  
  1013. #define        (kFishPerPlayer,                8)
  1014. #define        (kFishPerNeutral,                0)
  1015.  
  1016. #define        (kGoldPerPlayer,                1)
  1017. #define        (kGoldPerNeutral,                0)
  1018.  
  1019. #define        (kOilPerPlayer,                0)
  1020. #define        (kOilPerNeutral,                0)
  1021.  
  1022. #define        (kSteelPerPlayer,                1)
  1023. #define        (kSteelPerNeutral,            0)
  1024.  
  1025. #define        (kStonePerPlayer,                1)
  1026. #define        (kStonePerNeutral,            0)
  1027.  
  1028. #define        (kTreePerPlayer,                0)
  1029. #define        (kTreePerNeutral,                0)
  1030.  
  1031. //////////////////////////////////////////////////////////////////////
  1032. // forest definitions
  1033. #define        (kForestFreeRadius,            3)
  1034. #define        (kForestsPerPlayer,            3)
  1035. #define        (kForestChaosLevel,            0.1)
  1036. #define        (kMaxClumpsPerForest,            2)
  1037.  
  1038.  
  1039. #elif Is12Players
  1040. //////////////////////////////////////////////////////////////////////
  1041. // 12 PLAYERS...
  1042. //////////////////////////////////////////////////////////////////////
  1043.  
  1044. //////////////////////////////////////////////////////////////////////
  1045. // terrain definitions
  1046. #define        (kMinIntElevation,                -10)
  1047. #define        (kMaxIntElevation,                12)
  1048. #define        (kElevationScale,                      1)
  1049. #define        (kPercentLand,                    Between(0.56, 0.56))
  1050. #define        (kWaterBorder,                    0)
  1051. #define        (kRiverWidth,                    7)
  1052. #define        (kCoastToDeepWaterPercentage                1.0)
  1053. #define        (kHeightMapChaos,                    Between(6, 15))
  1054.         
  1055. #define        (kMinimumStartPositionToMapEdge        0)
  1056. #define        (kOuterPushFromMapCenter            12)
  1057. #define        (kInnerPushFromMapCenter             0)
  1058.  
  1059. //////////////////////////////////////////////////////////////////////
  1060. // player definitions
  1061. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1062. #define        (kPlayerInnerRadius,            0.01)
  1063. #define        (kPlayerOuterRadius,            0.9)
  1064. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1065. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1066. #define        (kPlayerLandChaos,            0.8)
  1067. #define        (kPlayerLandClumps,            1)
  1068. #define        (kPlayerFlatChaos,            0.8)
  1069. #define        (kPlayerFlatClumps,            2)
  1070. #define        (kPlayerTreePercentage,            0.04)
  1071.  
  1072.  
  1073. //////////////////////////////////////////////////////////////////////
  1074. // inner neutral definitions
  1075. #define        (kNeutralInnerRadius,            0.05)
  1076. #define        (kNeutralOuterRadius,            0.4)
  1077. #define        (kNeutralOptimalFactor,            0.7)
  1078. #define        (kNumInnerNeutrals,            Between(0, 0))
  1079. #define        (kInnerNeutralPercentLand,        0.35)
  1080. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1081. #define        (kInnerNeutralTreePercentage,          0.04)
  1082. #define        (kInnerNeutralLandChaos,        0.8)
  1083. #define        (kInnerNeutralLandClumps,        1)
  1084. #define        (kInnerNeutralFlatChaos,        0.8)
  1085. #define        (kInnerNeutralFlatClumps,        2)
  1086.  
  1087.  
  1088. //////////////////////////////////////////////////////////////////////
  1089. // outer neutral definitions
  1090. #define        (kNumOuterNeutrals,            Between(0, 0))
  1091. #define        (kOuterNeutralPercentLand,        0.35)
  1092. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1093. #define        (kOuterNeutralTreePercentage,          0.04)
  1094. #define        (kOuterNeutralLandChaos,        0.8)
  1095. #define        (kOuterNeutralLandClumps,        1)
  1096. #define        (kOuterNeutralFlatChaos,        0.8)
  1097. #define        (kOuterNeutralFlatClumps,        2)
  1098.  
  1099.  
  1100. //////////////////////////////////////////////////////////////////////
  1101. // resource definitions
  1102. #define        (kMaxResourceElevation,            2)
  1103. #define        (kResourceToEdgeDistance,        2)
  1104. #define        (kResourceToWaterDistance,        2)
  1105.  
  1106. #define        (kAnimalPerPlayer,            0)
  1107. #define        (kAnimalPerNeutral,            0)
  1108.  
  1109. #define        (kBerryPerPlayer,                0)
  1110. #define        (kBerryPerNeutral,            0)
  1111.  
  1112. #define        (kFishPerPlayer,                8)
  1113. #define        (kFishPerNeutral,                0)
  1114.  
  1115. #define        (kGoldPerPlayer,                1)
  1116. #define        (kGoldPerNeutral,                0)
  1117.  
  1118. #define        (kOilPerPlayer,                0)
  1119. #define        (kOilPerNeutral,                0)
  1120.  
  1121. #define        (kSteelPerPlayer,                1)
  1122. #define        (kSteelPerNeutral,            0)
  1123.  
  1124. #define        (kStonePerPlayer,                1)
  1125. #define        (kStonePerNeutral,            0)
  1126.  
  1127. #define        (kTreePerPlayer,                0)
  1128. #define        (kTreePerNeutral,                0)
  1129.  
  1130. //////////////////////////////////////////////////////////////////////
  1131. // forest definitions
  1132. #define        (kForestFreeRadius,            3)
  1133. #define        (kForestsPerPlayer,            3)
  1134. #define        (kForestChaosLevel,            0.1)
  1135. #define        (kMaxClumpsPerForest,            2)
  1136.  
  1137.  
  1138. #elif Is13Players
  1139. //////////////////////////////////////////////////////////////////////
  1140. // 13 PLAYERS...
  1141. //////////////////////////////////////////////////////////////////////
  1142.  
  1143. //////////////////////////////////////////////////////////////////////
  1144. // terrain definitions
  1145. #define        (kMinIntElevation,                -10)
  1146. #define        (kMaxIntElevation,                12)
  1147. #define        (kElevationScale,                      1)
  1148. #define        (kPercentLand,                    Between(0.55, 0.55))
  1149. #define        (kWaterBorder,                    0)
  1150. #define        (kRiverWidth,                    6)
  1151. #define        (kCoastToDeepWaterPercentage                1.0)
  1152. #define        (kHeightMapChaos,                    Between(6, 15))
  1153.         
  1154. #define        (kMinimumStartPositionToMapEdge        0)
  1155. #define        (kOuterPushFromMapCenter            11)
  1156. #define        (kInnerPushFromMapCenter             0)
  1157.  
  1158. //////////////////////////////////////////////////////////////////////
  1159. // player definitions
  1160. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1161. #define        (kPlayerInnerRadius,            0.01)
  1162. #define        (kPlayerOuterRadius,            0.9)
  1163. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1164. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1165. #define        (kPlayerLandChaos,            0.8)
  1166. #define        (kPlayerLandClumps,            1)
  1167. #define        (kPlayerFlatChaos,            0.8)
  1168. #define        (kPlayerFlatClumps,            2)
  1169. #define        (kPlayerTreePercentage,            0.04)
  1170.  
  1171.  
  1172. //////////////////////////////////////////////////////////////////////
  1173. // inner neutral definitions
  1174. #define        (kNeutralInnerRadius,            0.05)
  1175. #define        (kNeutralOuterRadius,            0.4)
  1176. #define        (kNeutralOptimalFactor,            0.7)
  1177. #define        (kNumInnerNeutrals,            Between(0, 0))
  1178. #define        (kInnerNeutralPercentLand,        0.35)
  1179. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1180. #define        (kInnerNeutralTreePercentage,          0.04)
  1181. #define        (kInnerNeutralLandChaos,        0.8)
  1182. #define        (kInnerNeutralLandClumps,        1)
  1183. #define        (kInnerNeutralFlatChaos,        0.8)
  1184. #define        (kInnerNeutralFlatClumps,        2)
  1185.  
  1186.  
  1187. //////////////////////////////////////////////////////////////////////
  1188. // outer neutral definitions
  1189. #define        (kNumOuterNeutrals,            Between(0, 0))
  1190. #define        (kOuterNeutralPercentLand,        0.35)
  1191. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1192. #define        (kOuterNeutralTreePercentage,          0.04)
  1193. #define        (kOuterNeutralLandChaos,        0.8)
  1194. #define        (kOuterNeutralLandClumps,        1)
  1195. #define        (kOuterNeutralFlatChaos,        0.8)
  1196. #define        (kOuterNeutralFlatClumps,        2)
  1197.  
  1198.  
  1199. //////////////////////////////////////////////////////////////////////
  1200. // resource definitions
  1201. #define        (kMaxResourceElevation,            2)
  1202. #define        (kResourceToEdgeDistance,        2)
  1203. #define        (kResourceToWaterDistance,        2)
  1204.  
  1205. #define        (kAnimalPerPlayer,            0)
  1206. #define        (kAnimalPerNeutral,            0)
  1207.  
  1208. #define        (kBerryPerPlayer,                0)
  1209. #define        (kBerryPerNeutral,            0)
  1210.  
  1211. #define        (kFishPerPlayer,                8)
  1212. #define        (kFishPerNeutral,                0)
  1213.  
  1214. #define        (kGoldPerPlayer,                1)
  1215. #define        (kGoldPerNeutral,                0)
  1216.  
  1217. #define        (kOilPerPlayer,                0)
  1218. #define        (kOilPerNeutral,                0)
  1219.  
  1220. #define        (kSteelPerPlayer,                1)
  1221. #define        (kSteelPerNeutral,            0)
  1222.  
  1223. #define        (kStonePerPlayer,                1)
  1224. #define        (kStonePerNeutral,            0)
  1225.  
  1226. #define        (kTreePerPlayer,                0)
  1227. #define        (kTreePerNeutral,                0)
  1228.  
  1229. //////////////////////////////////////////////////////////////////////
  1230. // forest definitions
  1231. #define        (kForestFreeRadius,            3)
  1232. #define        (kForestsPerPlayer,            3)
  1233. #define        (kForestChaosLevel,            0.1)
  1234. #define        (kMaxClumpsPerForest,            2)
  1235.  
  1236.  
  1237. #elif Is14Players
  1238. //////////////////////////////////////////////////////////////////////
  1239. // 14 PLAYERS...
  1240. //////////////////////////////////////////////////////////////////////
  1241.  
  1242. //////////////////////////////////////////////////////////////////////
  1243. // terrain definitions
  1244. #define        (kMinIntElevation,                -10)
  1245. #define        (kMaxIntElevation,                12)
  1246. #define        (kElevationScale,                      1)
  1247. #define        (kPercentLand,                    Between(0.54, 0.54))
  1248. #define        (kWaterBorder,                    0)
  1249. #define        (kRiverWidth,                    6)
  1250. #define        (kCoastToDeepWaterPercentage                1.0)
  1251. #define        (kHeightMapChaos,                    Between(6, 15))
  1252.         
  1253. #define        (kMinimumStartPositionToMapEdge        0)
  1254. #define        (kOuterPushFromMapCenter            11)
  1255. #define        (kInnerPushFromMapCenter             0)
  1256.  
  1257. //////////////////////////////////////////////////////////////////////
  1258. // player definitions
  1259. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1260. #define        (kPlayerInnerRadius,            0.01)
  1261. #define        (kPlayerOuterRadius,            0.9)
  1262. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1263. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1264. #define        (kPlayerLandChaos,            0.8)
  1265. #define        (kPlayerLandClumps,            1)
  1266. #define        (kPlayerFlatChaos,            0.8)
  1267. #define        (kPlayerFlatClumps,            2)
  1268. #define        (kPlayerTreePercentage,            0.04)
  1269.  
  1270.  
  1271. //////////////////////////////////////////////////////////////////////
  1272. // inner neutral definitions
  1273. #define        (kNeutralInnerRadius,            0.05)
  1274. #define        (kNeutralOuterRadius,            0.4)
  1275. #define        (kNeutralOptimalFactor,            0.7)
  1276. #define        (kNumInnerNeutrals,            Between(0, 0))
  1277. #define        (kInnerNeutralPercentLand,        0.35)
  1278. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1279. #define        (kInnerNeutralTreePercentage,          0.04)
  1280. #define        (kInnerNeutralLandChaos,        0.8)
  1281. #define        (kInnerNeutralLandClumps,        1)
  1282. #define        (kInnerNeutralFlatChaos,        0.8)
  1283. #define        (kInnerNeutralFlatClumps,        2)
  1284.  
  1285.  
  1286. //////////////////////////////////////////////////////////////////////
  1287. // outer neutral definitions
  1288. #define        (kNumOuterNeutrals,            Between(0, 0))
  1289. #define        (kOuterNeutralPercentLand,        0.35)
  1290. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1291. #define        (kOuterNeutralTreePercentage,          0.04)
  1292. #define        (kOuterNeutralLandChaos,        0.8)
  1293. #define        (kOuterNeutralLandClumps,        1)
  1294. #define        (kOuterNeutralFlatChaos,        0.8)
  1295. #define        (kOuterNeutralFlatClumps,        2)
  1296.  
  1297.  
  1298. //////////////////////////////////////////////////////////////////////
  1299. // resource definitions
  1300. #define        (kMaxResourceElevation,            2)
  1301. #define        (kResourceToEdgeDistance,        2)
  1302. #define        (kResourceToWaterDistance,        2)
  1303.  
  1304. #define        (kAnimalPerPlayer,            0)
  1305. #define        (kAnimalPerNeutral,            0)
  1306.  
  1307. #define        (kBerryPerPlayer,                0)
  1308. #define        (kBerryPerNeutral,            0)
  1309.  
  1310. #define        (kFishPerPlayer,                8)
  1311. #define        (kFishPerNeutral,                0)
  1312.  
  1313. #define        (kGoldPerPlayer,                1)
  1314. #define        (kGoldPerNeutral,                0)
  1315.  
  1316. #define        (kOilPerPlayer,                0)
  1317. #define        (kOilPerNeutral,                0)
  1318.  
  1319. #define        (kSteelPerPlayer,                1)
  1320. #define        (kSteelPerNeutral,            0)
  1321.  
  1322. #define        (kStonePerPlayer,                1)
  1323. #define        (kStonePerNeutral,            0)
  1324.  
  1325. #define        (kTreePerPlayer,                0)
  1326. #define        (kTreePerNeutral,                0)
  1327.  
  1328. //////////////////////////////////////////////////////////////////////
  1329. // forest definitions
  1330. #define        (kForestFreeRadius,            3)
  1331. #define        (kForestsPerPlayer,            3)
  1332. #define        (kForestChaosLevel,            0.1)
  1333. #define        (kMaxClumpsPerForest,            2)
  1334.  
  1335.  
  1336. #elif Is15Players
  1337. //////////////////////////////////////////////////////////////////////
  1338. // 15 PLAYERS...
  1339. //////////////////////////////////////////////////////////////////////
  1340.  
  1341. //////////////////////////////////////////////////////////////////////
  1342. // terrain definitions
  1343. #define        (kMinIntElevation,                -10)
  1344. #define        (kMaxIntElevation,                12)
  1345. #define        (kElevationScale,                      1)
  1346. #define        (kPercentLand,                    Between(0.52, 0.52))
  1347. #define        (kWaterBorder,                    0)
  1348. #define        (kRiverWidth,                    5)
  1349. #define        (kCoastToDeepWaterPercentage                1.0)
  1350. #define        (kHeightMapChaos,                    Between(6, 15))
  1351.         
  1352. #define        (kMinimumStartPositionToMapEdge        0)
  1353. #define        (kOuterPushFromMapCenter            10)
  1354. #define        (kInnerPushFromMapCenter             0)
  1355.  
  1356. //////////////////////////////////////////////////////////////////////
  1357. // player definitions
  1358. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1359. #define        (kPlayerInnerRadius,            0.01)
  1360. #define        (kPlayerOuterRadius,            0.9)
  1361. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1362. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1363. #define        (kPlayerLandChaos,            0.8)
  1364. #define        (kPlayerLandClumps,            1)
  1365. #define        (kPlayerFlatChaos,            0.8)
  1366. #define        (kPlayerFlatClumps,            2)
  1367. #define        (kPlayerTreePercentage,            0.04)
  1368.  
  1369.  
  1370. //////////////////////////////////////////////////////////////////////
  1371. // inner neutral definitions
  1372. #define        (kNeutralInnerRadius,            0.05)
  1373. #define        (kNeutralOuterRadius,            0.4)
  1374. #define        (kNeutralOptimalFactor,            0.7)
  1375. #define        (kNumInnerNeutrals,            Between(0, 0))
  1376. #define        (kInnerNeutralPercentLand,        0.35)
  1377. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1378. #define        (kInnerNeutralTreePercentage,          0.04)
  1379. #define        (kInnerNeutralLandChaos,        0.8)
  1380. #define        (kInnerNeutralLandClumps,        1)
  1381. #define        (kInnerNeutralFlatChaos,        0.8)
  1382. #define        (kInnerNeutralFlatClumps,        2)
  1383.  
  1384.  
  1385. //////////////////////////////////////////////////////////////////////
  1386. // outer neutral definitions
  1387. #define        (kNumOuterNeutrals,            Between(0, 0))
  1388. #define        (kOuterNeutralPercentLand,        0.35)
  1389. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1390. #define        (kOuterNeutralTreePercentage,          0.04)
  1391. #define        (kOuterNeutralLandChaos,        0.8)
  1392. #define        (kOuterNeutralLandClumps,        1)
  1393. #define        (kOuterNeutralFlatChaos,        0.8)
  1394. #define        (kOuterNeutralFlatClumps,        2)
  1395.  
  1396.  
  1397. //////////////////////////////////////////////////////////////////////
  1398. // resource definitions
  1399. #define        (kMaxResourceElevation,            2)
  1400. #define        (kResourceToEdgeDistance,        2)
  1401. #define        (kResourceToWaterDistance,        2)
  1402.  
  1403. #define        (kAnimalPerPlayer,            0)
  1404. #define        (kAnimalPerNeutral,            0)
  1405.  
  1406. #define        (kBerryPerPlayer,                0)
  1407. #define        (kBerryPerNeutral,            0)
  1408.  
  1409. #define        (kFishPerPlayer,                7)
  1410. #define        (kFishPerNeutral,                0)
  1411.  
  1412. #define        (kGoldPerPlayer,                1)
  1413. #define        (kGoldPerNeutral,                0)
  1414.  
  1415. #define        (kOilPerPlayer,                0)
  1416. #define        (kOilPerNeutral,                0)
  1417.  
  1418. #define        (kSteelPerPlayer,                1)
  1419. #define        (kSteelPerNeutral,            0)
  1420.  
  1421. #define        (kStonePerPlayer,                1)
  1422. #define        (kStonePerNeutral,            0)
  1423.  
  1424. #define        (kTreePerPlayer,                0)
  1425. #define        (kTreePerNeutral,                0)
  1426.  
  1427. //////////////////////////////////////////////////////////////////////
  1428. // forest definitions
  1429. #define        (kForestFreeRadius,            3)
  1430. #define        (kForestsPerPlayer,            3)
  1431. #define        (kForestChaosLevel,            0.1)
  1432. #define        (kMaxClumpsPerForest,            2)
  1433.  
  1434.  
  1435. #elif Is16Players
  1436. //////////////////////////////////////////////////////////////////////
  1437. // 16 PLAYERS...
  1438. //////////////////////////////////////////////////////////////////////
  1439.  
  1440. //////////////////////////////////////////////////////////////////////
  1441. // terrain definitions
  1442. #define        (kMinIntElevation,                -10)
  1443. #define        (kMaxIntElevation,                12)
  1444. #define        (kElevationScale,                      1)
  1445. #define        (kPercentLand,                    Between(0.5, 0.5))
  1446. #define        (kWaterBorder,                    0)
  1447. #define        (kRiverWidth,                    5)
  1448. #define        (kCoastToDeepWaterPercentage                1.0)
  1449. #define        (kHeightMapChaos,                    Between(6, 15))
  1450.         
  1451. #define        (kMinimumStartPositionToMapEdge        0)
  1452. #define        (kOuterPushFromMapCenter            9)
  1453. #define        (kInnerPushFromMapCenter             0)
  1454.  
  1455. //////////////////////////////////////////////////////////////////////
  1456. // player definitions
  1457. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1458. #define        (kPlayerInnerRadius,            0.01)
  1459. #define        (kPlayerOuterRadius,            0.9)
  1460. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1461. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1462. #define        (kPlayerLandChaos,            0.8)
  1463. #define        (kPlayerLandClumps,            1)
  1464. #define        (kPlayerFlatChaos,            0.8)
  1465. #define        (kPlayerFlatClumps,            2)
  1466. #define        (kPlayerTreePercentage,            0.04)
  1467.  
  1468.  
  1469. //////////////////////////////////////////////////////////////////////
  1470. // inner neutral definitions
  1471. #define        (kNeutralInnerRadius,            0.05)
  1472. #define        (kNeutralOuterRadius,            0.4)
  1473. #define        (kNeutralOptimalFactor,            0.7)
  1474. #define        (kNumInnerNeutrals,            Between(0, 0))
  1475. #define        (kInnerNeutralPercentLand,        0.35)
  1476. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1477. #define        (kInnerNeutralTreePercentage,          0.04)
  1478. #define        (kInnerNeutralLandChaos,        0.8)
  1479. #define        (kInnerNeutralLandClumps,        1)
  1480. #define        (kInnerNeutralFlatChaos,        0.8)
  1481. #define        (kInnerNeutralFlatClumps,        2)
  1482.  
  1483.  
  1484. //////////////////////////////////////////////////////////////////////
  1485. // outer neutral definitions
  1486. #define        (kNumOuterNeutrals,            Between(0, 0))
  1487. #define        (kOuterNeutralPercentLand,        0.35)
  1488. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1489. #define        (kOuterNeutralTreePercentage,          0.04)
  1490. #define        (kOuterNeutralLandChaos,        0.8)
  1491. #define        (kOuterNeutralLandClumps,        1)
  1492. #define        (kOuterNeutralFlatChaos,        0.8)
  1493. #define        (kOuterNeutralFlatClumps,        2)
  1494.  
  1495.  
  1496. //////////////////////////////////////////////////////////////////////
  1497. // resource definitions
  1498. #define        (kMaxResourceElevation,            2)
  1499. #define        (kResourceToEdgeDistance,        2)
  1500. #define        (kResourceToWaterDistance,        2)
  1501.  
  1502. #define        (kAnimalPerPlayer,            0)
  1503. #define        (kAnimalPerNeutral,            0)
  1504.  
  1505. #define        (kBerryPerPlayer,                0)
  1506. #define        (kBerryPerNeutral,            0)
  1507.  
  1508. #define        (kFishPerPlayer,                7)
  1509. #define        (kFishPerNeutral,                0)
  1510.  
  1511. #define        (kGoldPerPlayer,                1)
  1512. #define        (kGoldPerNeutral,                0)
  1513.  
  1514. #define        (kOilPerPlayer,                0)
  1515. #define        (kOilPerNeutral,                0)
  1516.  
  1517. #define        (kSteelPerPlayer,                1)
  1518. #define        (kSteelPerNeutral,            0)
  1519.  
  1520. #define        (kStonePerPlayer,                1)
  1521. #define        (kStonePerNeutral,            0)
  1522.  
  1523. #define        (kTreePerPlayer,                0)
  1524. #define        (kTreePerNeutral,                0)
  1525.  
  1526. //////////////////////////////////////////////////////////////////////
  1527. // forest definitions
  1528. #define        (kForestFreeRadius,            3)
  1529. #define        (kForestsPerPlayer,            3)
  1530. #define        (kForestChaosLevel,            0.1)
  1531. #define        (kMaxClumpsPerForest,            2)
  1532.  
  1533.  
  1534.  
  1535. //////////////////////////////////////////////////////////////////////
  1536. // End of if...elif... command
  1537. #endif
  1538.  
  1539. #endif        // NOTDEFINED(TOURNAMENT_ISLANDS_LARGE_RMV)